#include "Hobbit.h"

using namespace std;
using namespace boost::assign;

const unsigned int Hobbit::ens = 3;

const unsigned int Hobbit::nbr_comp = 5;

const vector< vector< unsigned int > > Hobbit::ensemble_racial =
  list_of< vector< unsigned int> >
  ( list_of( 1)( 9)( 6)( 3)( 8) ) // costauds
  ( list_of( 1)( 4)( 3)(11)( 8) ) // grand-gars
  ( list_of( 1)( 3)( 8) );        // pieds-velus

const unsigned int Hobbit::taille = 11;

/**
 * Contient les capacités, puis les ensembles raciaux, à la fin.
 */
const vector< ListCapa > Hobbit::Liste = list_of
  (ListCapa("Bonus à l'attaque"  ,  5))
  (ListCapa("Bonus à la réaction",  5))
  (ListCapa("Bonus aux JS"       ,  5))
  (ListCapa("Camouflage"         , 10))
  (ListCapa("Détection du mal"   ,  5))
  (ListCapa("Détection minière"  ,  5))
  (ListCapa("Dextérité renforcée", 20))
  (ListCapa("Furtivité"          , 10))
  (ListCapa("Infravision"        ,  5))
  (ListCapa("Moquerie"           ,  5))
  (ListCapa("Portes secrètes"    ,  5))
  (ListCapa("Costaud"            , 35))
  (ListCapa("Grand-Gars"         , 35))
  (ListCapa("Pieds-Velus"        , 30));

/**
 * Contient la liste des ensembles raciaux.
 */
const vector< ListCapa > Hobbit::Ensembles = list_of
  (ListCapa("Costaud"            , 35))
  (ListCapa("Grand-Gars"         , 35))
  (ListCapa("Pieds-Velus"        , 30));

const vector< Prerequis > Hobbit::Limites = list_of
  (Prerequis(0,  7, 18))
  (Prerequis(1,  7, 18))
  (Prerequis(2, 10, 18))
  (Prerequis(3,  6, 18))
  (Prerequis(4,  3, 17));

/**
 * Constructeur simplifié, qui remplit simplement le conteneur des capacités.
 * Il est utilisé lors de la lecture d'un fichier XML.
 * @param cap conteneur des capacité
 */
Hobbit::Hobbit(vector<unsigned int> cap)
  :Race("Hobbit")
{
  ptrCapa      = &Liste;
  ptrNbrCapa   = &taille;
  ptrEns       = &ensemble_racial;
  ptrNbrEns    = &ens;
  ptrMaxEns    = &nbr_comp;
  ptrNomEns    = &Ensembles;
  ptrPreRequis = &Limites;

  capacites.assign( cap.begin(), cap.end() );
}

/**
 * Constructeur usuel, qui permet de créer un Hobbit en sélectionnant
 * ses capacités.
 * @param PP nombre de pp, passé en argument afin de pouvoir récupéré les
 * pp non dépensé
 */
Hobbit::Hobbit(unsigned int& PP)
  :Race("Hobbit")
{
  ptrCapa      = &Liste;
  ptrNbrCapa   = &taille;
  ptrEns       = &ensemble_racial;
  ptrNbrEns    = &ens;
  ptrMaxEns    = &nbr_comp;
  ptrNomEns    = &Ensembles;
  ptrPreRequis = &Limites;

  blank() << setfill('*') << setw(56) << '*' << endreq;
  blank() << "Création d'un hobbit" << endl << endreq;

  PP += 35;
  construitRace( PP );
  
//   unsigned int nbr(0);
//   bool test(true), deja_pris, encore(false);
//   PP = 35;
//   do
//     {
//       blank() << "Tu as 35 pp à dépenser" << endreq;
//       for (unsigned int i(0); i<taille; i++)
// 	blank() << i+1 << ' ' << (Liste[i].Capa)
// 		    << " (" << Liste[i].Cout << " pp)" << endreq;
//       blank() << taille+1 << " Aucune" << endreq;
//       blank() << "Choisir les capacités raciales" << endreq;
//       while(test)
// 	{
// 	  nbr = demanderUnsignedBorne("("+ecrireString(PP)+" pp restants ",
// 					1, taille + 1);
// 	  if (nbr == taille+1)
// 	    test = false;
// 	  else
// 	    {
// 	      if (PP >= Liste[nbr-1].Cout)
// 		{
// 		  PP -= Liste[nbr-1].Cout;
// 		  if (nbr<13)
// 		    {
// 		      deja_pris = safePushBack(&capacites, nbr - 1);
// 		      if (deja_pris)
// 			warning() << "Déjà sélectionné" << endreq;
// 		      else
// 			{
// 			  capacites.push_back(nbr-1);
// 			  blank() << "Capacité choisie : "
// 				      << (Liste[nbr-1].Capa) << endreq;
// 			}
// 		    }
// 		  else
// 		    {
// 		      blank() << "Achat de l'ensemble racial : "
// 				  << (Liste[nbr-1].Capa) << endreq;
// 		      for (unsigned int i(0); i < nbr_comp; i++)
// 			{
// 			  if (ensemble_racial[nbr-13][i] != 0)
// 			    capacites.push_back(ensemble_racial[nbr-13][i]-1);
// 			}
// 		    }
// 		}
// 	      else
// 		blank() << "Pas assez de pp" << endreq;
// 	    }
// 	}
      
//       afficheInfo();
//       blank() << endl <<  "1 pour continuer, 2 pour recommencer" << endreq;
//       nbr = demanderUnsignedBorne("Choix ", 1, 2);
//       if (nbr == 2)
// 	{
// 	  PP = 35;
// 	  capacites.clear();
// 	  test = true;
// 	  encore = true;
// 	  blank() << endreq;
// 	}
//       else
// 	encore = false;
//     }
//   while(encore);
  
  blank() << endl << setfill('*') << setw(56) << '*' << endreq;
}

Hobbit::Hobbit()
  :Race("Hobbit")
{
  ptrCapa      = &Liste;
  ptrNbrCapa   = &taille;
  ptrEns       = &ensemble_racial;
  ptrNbrEns    = &ens;
  ptrMaxEns    = &nbr_comp;
  ptrNomEns    = &Ensembles;
  ptrPreRequis = &Limites;
}

/**
 * Destructeur, ne fait rien de spécial.
 */
Hobbit::~Hobbit()
{}

/**
 * Les Hobbits ont +1 en Dextérité et -1 en Force.
 * @param tab traits du personnage
 */
void Hobbit::appliquerAjustements(unsigned int tab[6])
{
  tab[1]++;
  tab[0]--;
}

// /**
//  * Affiche la race et les capacités
//  */
// void Hobbit::affiche_info(ostream& os)
// {
//   os << "Race : " << Type << endreq;
//   for (unsigned int i(0); i<capacites.size(); i++)
//     os << (Liste[capacites[i]].Capa) << endreq;
// }

// /**
//  * Retrouve la capacité voulue.
//  * @param i le numéro de la capacité
//  * @return la capacité (string)
//  */
// string Hobbit::get_capacite(const unsigned int& i) const
// {
//   return (Liste[get_capa(i)].Capa);
// }

// void Hobbit::get_capacites(unsigned int& nbr, vector<ListCapa> &capa) const
// {
//   nbr = taille;

//   capa.clear();

//   for (unsigned int i(0); i < taille; i++)
//     capa.push_back(Liste[i]);
// }

// void Hobbit::get_ensemble_racial(unsigned int& nbr, unsigned int& max) const
// {
//   nbr = ens;
//   max = nbr_comp;
// }

// const unsigned int* Hobbit::get_ensemble_racial(const unsigned int& nbr) const
// {
//   return &ensemble_racial[nbr][0];
// }
